home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / Voyeur 1.1.1 / source / Voyeur ƒ / MSG Shell ƒ / msg menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  5.7 KB  |  285 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        msg menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7.  
  8.  
  9. Voyeur -- a no-frills file viewer
  10. Copyright ©1993-4, Mark Pilgrim
  11.  
  12. This program is free software; you can redistribute it and/or modify
  13. it under the terms of the GNU General Public License as published by
  14. the Free Software Foundation; either version 2 of the License, or
  15. (at your option) any later version.
  16.  
  17. This program is distributed in the hope that it will be useful,
  18. but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. GNU General Public License for more details.
  21.  
  22. You should have received a copy of the GNU General Public License
  23. along with this program in a file named "GNU General Public License".
  24. If not, write to the Free Software Foundation, 675 Mass Ave,
  25. Cambridge, MA 02139, USA.
  26.  
  27. \**********************************************************************/
  28.  
  29. #include "msg graphics.h"
  30. #include "msg menus.h"
  31. #include "msg prefs.h"
  32. #include "msg environment.h"
  33. #include "msg help.h"
  34. #include "v.h"
  35. #include "v meat.h"
  36. #include "v find.h"
  37. #include "program globals.h"
  38. #include "v error.h"
  39. #include "v type creator.h"
  40. #include "v window maintenance.h"
  41.  
  42.  
  43. MenuHandle        gAppleMenu;
  44. MenuHandle        gFileMenu;
  45. MenuHandle        gEditMenu;
  46. MenuHandle        gViewMenu;
  47. MenuHandle        gOptionsMenu;
  48. MenuHandle        gHelpMenu;
  49. MenuHandle        gWindowMenu;
  50.  
  51. void AdjustMenus(void)
  52. {
  53.     WindowPeek        theWindow;
  54.     int                kind;
  55.     int                i;
  56.     int                numWindows;
  57.     
  58.     theWindow = (WindowPeek)FrontWindow();
  59.     kind = theWindow ? theWindow->windowKind : 0;
  60.     
  61.     if (!gInProgress)
  62.     {
  63.         EnableItem(gAppleMenu, aboutItem);
  64.         EnableItem(gAppleMenu, aboutMSGItem);
  65.         EnableItem(gAppleMenu, helpItem);
  66.         if(kind < 0) EnableItem(gEditMenu, 0);
  67.         else DisableItem(gEditMenu, 0);
  68.         EnableItem(gFileMenu, 0);
  69.         EnableItem(gViewMenu, 0);
  70.         EnableItem(gOptionsMenu, 0);
  71.         EnableItem(gWindowMenu, 0);
  72.         
  73.         if (theWindow)
  74.         {
  75.             EnableItem(gFileMenu, closeItem);
  76.             EnableItem(gFileMenu, closeAllItem);
  77.         }
  78.         else
  79.         {
  80.             DisableItem(gFileMenu, closeItem);
  81.             DisableItem(gFileMenu, closeAllItem);
  82.         }
  83.         
  84.         numWindows=CountProgramWindows();
  85.         
  86.         if (numWindows>0)
  87.         {
  88.             if (numWindows==MAX_WINDOWS)
  89.                 DisableItem(gFileMenu, openItem);
  90.             else
  91.                 EnableItem(gFileMenu, openItem);
  92.             EnableItem(gViewMenu, 0);
  93.             EnableItem(gOptionsMenu, 0);
  94.             CheckItem(gViewMenu, dataForkItem, (gWhichFork[gWhichFile]==0));
  95.             CheckItem(gViewMenu, resourceForkItem, (gWhichFork[gWhichFile]==1));
  96.             if ((gFindHex ? gFindHexStringInAscii[0] : gFindString[0])==0x00)
  97.                 DisableItem(gOptionsMenu, findAgainItem);
  98.             else
  99.                 EnableItem(gOptionsMenu, findAgainItem);
  100.         }
  101.         else
  102.         {
  103.             EnableItem(gFileMenu, openItem);
  104.             CheckItem(gViewMenu, dataForkItem, FALSE);
  105.             CheckItem(gViewMenu, resourceForkItem, FALSE);
  106.             DisableItem(gViewMenu, 0);
  107.             DisableItem(gOptionsMenu, 0);
  108.         }
  109.         
  110.         if (gWindowMenu!=0L)
  111.             for (i=1; i<=numWindows; i++)
  112.                 CheckItem(gWindowMenu, i, FrontWindow()==GetProgramWindowFromIndex(i-1));
  113.     }
  114.     else
  115.     {
  116.         DisableItem(gAppleMenu, aboutItem);
  117.         DisableItem(gAppleMenu, aboutMSGItem);
  118.         DisableItem(gAppleMenu, helpItem);
  119.         DisableItem(gFileMenu, 0);
  120.         DisableItem(gViewMenu, 0);
  121.         DisableItem(gOptionsMenu, 0);
  122.         DisableItem(gWindowMenu, 0);
  123.     }
  124. }
  125.  
  126. void HandleMenu(long mSelect)
  127. {
  128.     int            menuID = HiWord(mSelect);
  129.     int            menuItem = LoWord(mSelect);
  130.     
  131.     switch (menuID)
  132.     {
  133.         case appleMenu:
  134.             HandleAppleMenu(menuItem);
  135.             break;
  136.         case fileMenu:
  137.             HandleFileMenu(menuItem);
  138.             break;    
  139.         case editMenu:
  140.             HandleEditMenu(menuItem);
  141.             break;
  142.         case viewMenu:
  143.             HandleViewMenu(menuItem);
  144.             break;
  145.         case optionsMenu:
  146.             HandleOptionsMenu(menuItem);
  147.             break;
  148.         case helpMenu:
  149.             HandleHelpMenu(menuItem);
  150.             break;
  151.         case windowMenu:
  152.             HandleWindowMenu(menuItem);
  153.             break;
  154.       }
  155. }
  156.  
  157. void HandleAppleMenu(int menuItem)
  158. {
  159.     GrafPtr        savePort;
  160.     Str255        name;
  161.     
  162.     if(menuItem == 1)
  163.         OpenTheWindow(kAbout);
  164.     if (menuItem == 2)
  165.         OpenTheWindow(kAboutMSG);
  166.     else if(menuItem > 4)
  167.     {
  168.         GetPort(&savePort);
  169.         GetItem(gAppleMenu, menuItem, name);
  170.         OpenDeskAcc(name);
  171.         SetPort(savePort);
  172.     }
  173. }
  174.  
  175. void DoTheCloseThing(WindowPtr theWindow)
  176. {
  177.     Boolean            gotone;
  178.     int                i;
  179.     
  180.     if (IsProgramWindow(theWindow))
  181.         CloseProgramWindow(GetProgramWindowIndex(theWindow));
  182.     else
  183.     {
  184.         gotone=FALSE;
  185.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  186.             gotone=(theWindow==gTheWindow[i]);
  187.             
  188.         if (gotone)
  189.             CloseTheWindow(i-1);
  190.         else
  191.             DisposeWindow(theWindow);
  192.     }
  193.     
  194.     AdjustMenus();
  195. }
  196.  
  197. void HandleFileMenu(int menuItem)
  198. {
  199.     switch (menuItem)
  200.     {
  201.         case openItem:
  202.             HandleError(NewEditWindow());
  203.             break;
  204.         case closeItem:
  205.             DoTheCloseThing(FrontWindow());
  206.             break;
  207.         case closeAllItem:
  208.             while (FrontWindow()!=0L)
  209.                 DoTheCloseThing(FrontWindow());
  210.             break;
  211.         case quitItem:
  212.             gDone = TRUE;
  213.             break;
  214.     }
  215. }
  216.  
  217. void HandleEditMenu(int menuItem)
  218. {
  219.     if ((menuItem>0) && (menuItem!=2))
  220.         if(!SystemEdit(menuItem - 1))
  221.             if(menuItem == undoItem)
  222.                 ProgramUndo();
  223. }
  224.  
  225. void HandleViewMenu(int menuItem)
  226. {
  227.     switch (menuItem)
  228.     {
  229.         case dataForkItem:
  230.             DoDataFork();
  231.             break;
  232.         case resourceForkItem:
  233.             DoResourceFork();
  234.             break;
  235.         case forwardItem:
  236.             GoForward();
  237.             break;
  238.         case backItem:
  239.             GoBack();
  240.             break;
  241.         case beginningItem:
  242.             GoBeginning();
  243.             break;
  244.         case endItem:
  245.             GoEnd();
  246.             break;
  247.         case offsetItem:
  248.             GoOffset();
  249.             break;
  250.     }
  251. }
  252.  
  253. void HandleOptionsMenu(int menuItem)
  254. {
  255.     switch (menuItem)
  256.     {
  257.         case typeCreatorItem:
  258.             ChangeTypeCreator();
  259.             break;
  260.         case eofItem:
  261.             ChangeEOF();
  262.             break;
  263.         case findItem:
  264.             DoFind(FALSE);
  265.             break;
  266.         case findHexItem:
  267.             DoFind(TRUE);
  268.             break;
  269.         case findAgainItem:
  270.             DoFindAgain();
  271.             break;
  272.     }
  273. }
  274.  
  275. void HandleHelpMenu(int menuItem)
  276. {
  277.     gWhichHelp=menuItem;
  278.     UpdateHelpWindow();
  279. }
  280.  
  281. void HandleWindowMenu(int menuItem)
  282. {
  283.     SelectProgramWindow(gTheWindow[kMainWindow+menuItem-1]);
  284. }
  285.